home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / api1.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  40KB  |  1,884 lines
  1. /* $Id: api1.c,v 3.4 1998/03/27 03:30:36 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: api1.c,v $
  26.  * Revision 3.4  1998/03/27 03:30:36  brianp
  27.  * fixed G++ warnings
  28.  *
  29.  * Revision 3.3  1998/02/20 04:49:19  brianp
  30.  * move extension functions into apiext.c
  31.  *
  32.  * Revision 3.2  1998/02/08 20:23:49  brianp
  33.  * lots of bitmap rendering changes
  34.  *
  35.  * Revision 3.1  1998/02/01 20:05:10  brianp
  36.  * added glDrawRangeElements()
  37.  *
  38.  * Revision 3.0  1998/01/31 20:42:56  brianp
  39.  * initial rev
  40.  *
  41.  */
  42.  
  43.  
  44. #ifdef PC_HEADER
  45. #include "all.h"
  46. #else
  47. #include <stdio.h>
  48. #include <stdlib.h>
  49. #include "api.h"
  50. #include "bitmap.h"
  51. #include "context.h"
  52. #include "drawpix.h"
  53. #include "eval.h"
  54. #include "image.h"
  55. #include "macros.h"
  56. #include "matrix.h"
  57. #include "teximage.h"
  58. #include "types.h"
  59. #include "vb.h"
  60. #endif
  61.  
  62.  
  63. /*
  64.  * Part 1 of API functions
  65.  */
  66.  
  67.  
  68.  
  69. void APIENTRY glAccum( GLenum op, GLfloat value )
  70. {
  71.    GET_CONTEXT;
  72.    CHECK_CONTEXT;
  73.    (*CC->API.Accum)(CC, op, value);
  74. }
  75.  
  76.  
  77. void APIENTRY glAlphaFunc( GLenum func, GLclampf ref )
  78. {
  79.    GET_CONTEXT;
  80.    CHECK_CONTEXT;
  81.    (*CC->API.AlphaFunc)(CC, func, ref);
  82. }
  83.  
  84.  
  85. GLboolean APIENTRY glAreTexturesResident( GLsizei n, const GLuint *textures,
  86.                                  GLboolean *residences )
  87. {
  88.    GET_CONTEXT;
  89.    CHECK_CONTEXT_RETURN(GL_FALSE);
  90.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  91. }
  92.  
  93.  
  94. void APIENTRY glArrayElement( GLint i )
  95. {
  96.    GET_CONTEXT;
  97.    CHECK_CONTEXT;
  98.    (*CC->API.ArrayElement)(CC, i);
  99. }
  100.  
  101.  
  102. void APIENTRY glBegin( GLenum mode )
  103. {
  104.    GET_CONTEXT;
  105.    CHECK_CONTEXT;
  106.    (*CC->API.Begin)( CC, mode );
  107. }
  108.  
  109.  
  110. void APIENTRY glBindTexture( GLenum target, GLuint texture )
  111. {
  112.    GET_CONTEXT;
  113.    CHECK_CONTEXT;
  114.    (*CC->API.BindTexture)(CC, target, texture);
  115. }
  116.  
  117.  
  118. void APIENTRY glBitmap( GLsizei width, GLsizei height,
  119.                         GLfloat xorig, GLfloat yorig,
  120.                         GLfloat xmove, GLfloat ymove,
  121.                         const GLubyte *bitmap )
  122. {
  123.    GET_CONTEXT;
  124.    CHECK_CONTEXT;
  125.    if (!CC->DirectContext || CC->CompileFlag
  126.        || !gl_direct_bitmap( CC, width, height, xorig, yorig,
  127.                              xmove, ymove, bitmap)) {
  128.       struct gl_image *image;
  129.       image = gl_unpack_bitmap( CC, width, height, bitmap );
  130.       (*CC->API.Bitmap)( CC, width, height, xorig, yorig,
  131.                          xmove, ymove, image );
  132.       if (image && image->RefCount==0) {
  133.          gl_free_image( image );
  134.       }
  135.    }
  136. }
  137.  
  138.  
  139. void APIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor )
  140. {
  141.    GET_CONTEXT;
  142.    CHECK_CONTEXT;
  143.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  144. }
  145.  
  146.  
  147. void APIENTRY glCallList( GLuint list )
  148. {
  149.    GET_CONTEXT;
  150.    CHECK_CONTEXT;
  151.    (*CC->API.CallList)(CC, list);
  152. }
  153.  
  154.  
  155. void APIENTRY glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
  156. {
  157.    GET_CONTEXT;
  158.    CHECK_CONTEXT;
  159.    (*CC->API.CallLists)(CC, n, type, lists);
  160. }
  161.  
  162.  
  163. void APIENTRY glClear( GLbitfield mask )
  164. {
  165.    GET_CONTEXT;
  166.    CHECK_CONTEXT;
  167.    (*CC->API.Clear)(CC, mask);
  168. }
  169.  
  170.  
  171. void APIENTRY glClearAccum( GLfloat red, GLfloat green,
  172.               GLfloat blue, GLfloat alpha )
  173. {
  174.    GET_CONTEXT;
  175.    CHECK_CONTEXT;
  176.    (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
  177. }
  178.  
  179.  
  180.  
  181. void APIENTRY glClearIndex( GLfloat c )
  182. {
  183.    GET_CONTEXT;
  184.    CHECK_CONTEXT;
  185.    (*CC->API.ClearIndex)(CC, c);
  186. }
  187.  
  188.  
  189. void APIENTRY glClearColor( GLclampf red,
  190.               GLclampf green,
  191.               GLclampf blue,
  192.               GLclampf alpha )
  193. {
  194.    GET_CONTEXT;
  195.    CHECK_CONTEXT;
  196.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  197. }
  198.  
  199.  
  200. void APIENTRY glClearDepth( GLclampd depth )
  201. {
  202.    GET_CONTEXT;
  203.    CHECK_CONTEXT;
  204.    (*CC->API.ClearDepth)( CC, depth );
  205. }
  206.  
  207.  
  208. void APIENTRY glClearStencil( GLint s )
  209. {
  210.    GET_CONTEXT;
  211.    CHECK_CONTEXT;
  212.    (*CC->API.ClearStencil)(CC, s);
  213. }
  214.  
  215.  
  216. void APIENTRY glClipPlane( GLenum plane, const GLdouble *equation )
  217. {
  218.    GLfloat eq[4];
  219.    GET_CONTEXT;
  220.    CHECK_CONTEXT;
  221.    eq[0] = (GLfloat) equation[0];
  222.    eq[1] = (GLfloat) equation[1];
  223.    eq[2] = (GLfloat) equation[2];
  224.    eq[3] = (GLfloat) equation[3];
  225.    (*CC->API.ClipPlane)(CC, plane, eq );
  226. }
  227.  
  228.  
  229. void APIENTRY glColor3b( GLbyte red, GLbyte green, GLbyte blue )
  230. {
  231.    GET_CONTEXT;
  232.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  233.                        BYTE_TO_FLOAT(blue) );
  234. }
  235.  
  236.  
  237. void APIENTRY glColor3d( GLdouble red, GLdouble green, GLdouble blue )
  238. {
  239.    GET_CONTEXT;
  240.    (*CC->API.Color3f)( CC, (GLfloat) red, (GLfloat) green, (GLfloat) blue );
  241. }
  242.  
  243.  
  244. void APIENTRY glColor3f( GLfloat red, GLfloat green, GLfloat blue )
  245. {
  246.    GET_CONTEXT;
  247.    (*CC->API.Color3f)( CC, red, green, blue );
  248. }
  249.  
  250.  
  251. void APIENTRY glColor3i( GLint red, GLint green, GLint blue )
  252. {
  253.    GET_CONTEXT;
  254.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  255.                        INT_TO_FLOAT(blue) );
  256. }
  257.  
  258.  
  259. void APIENTRY glColor3s( GLshort red, GLshort green, GLshort blue )
  260. {
  261.    GET_CONTEXT;
  262.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  263.                        SHORT_TO_FLOAT(blue) );
  264. }
  265.  
  266.  
  267. void APIENTRY glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
  268. {
  269.    GET_CONTEXT;
  270.    (*CC->API.Color4ub)( CC, red, green, blue, 255 );
  271. }
  272.  
  273.  
  274. void APIENTRY glColor3ui( GLuint red, GLuint green, GLuint blue )
  275. {
  276.    GET_CONTEXT;
  277.    (*CC->API.Color3f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  278.                        UINT_TO_FLOAT(blue) );
  279. }
  280.  
  281.  
  282. void APIENTRY glColor3us( GLushort red, GLushort green, GLushort blue )
  283. {
  284.    GET_CONTEXT;
  285.    (*CC->API.Color3f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  286.                        USHORT_TO_FLOAT(blue) );
  287. }
  288.  
  289.  
  290. void APIENTRY glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
  291. {
  292.    GET_CONTEXT;
  293.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  294.                        BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
  295. }
  296.  
  297.  
  298. void APIENTRY glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
  299. {
  300.    GET_CONTEXT;
  301.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  302.                        (GLfloat) blue, (GLfloat) alpha );
  303. }
  304.  
  305.  
  306. void APIENTRY glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
  307. {
  308.    GET_CONTEXT;
  309.    (*CC->API.Color4f)( CC, red, green, blue, alpha );
  310. }
  311.  
  312. void APIENTRY glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
  313. {
  314.    GET_CONTEXT;
  315.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  316.                        INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
  317. }
  318.  
  319.  
  320. void APIENTRY glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
  321. {
  322.    GET_CONTEXT;
  323.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  324.                        SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
  325. }
  326.  
  327. void APIENTRY glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
  328. {
  329.    GET_CONTEXT;
  330.    (*CC->API.Color4ub)( CC, red, green, blue, alpha );
  331. }
  332.  
  333. void APIENTRY glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
  334. {
  335.    GET_CONTEXT;
  336.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  337.                        UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
  338. }
  339.  
  340. void APIENTRY glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
  341. {
  342.    GET_CONTEXT;
  343.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  344.                        USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
  345. }
  346.  
  347.  
  348. void APIENTRY glColor3bv( const GLbyte *v )
  349. {
  350.    GET_CONTEXT;
  351.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  352.                        BYTE_TO_FLOAT(v[2]) );
  353. }
  354.  
  355.  
  356. void APIENTRY glColor3dv( const GLdouble *v )
  357. {
  358.    GET_CONTEXT;
  359.    (*CC->API.Color3f)( CC, (GLdouble) v[0], (GLdouble) v[1], (GLdouble) v[2] );
  360. }
  361.  
  362.  
  363. void APIENTRY glColor3fv( const GLfloat *v )
  364. {
  365.    GET_CONTEXT;
  366.    (*CC->API.Color3fv)( CC, v );
  367. }
  368.  
  369.  
  370. void APIENTRY glColor3iv( const GLint *v )
  371. {
  372.    GET_CONTEXT;
  373.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  374.                        INT_TO_FLOAT(v[2]) );
  375. }
  376.  
  377.  
  378. void APIENTRY glColor3sv( const GLshort *v )
  379. {
  380.    GET_CONTEXT;
  381.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  382.                        SHORT_TO_FLOAT(v[2]) );
  383. }
  384.  
  385.  
  386. void APIENTRY glColor3ubv( const GLubyte *v )
  387. {
  388.    GET_CONTEXT;
  389.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], 255 );
  390. }
  391.  
  392.  
  393. void APIENTRY glColor3uiv( const GLuint *v )
  394. {
  395.    GET_CONTEXT;
  396.    (*CC->API.Color3f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  397.                        UINT_TO_FLOAT(v[2]) );
  398. }
  399.  
  400.  
  401. void APIENTRY glColor3usv( const GLushort *v )
  402. {
  403.    GET_CONTEXT;
  404.    (*CC->API.Color3f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  405.                        USHORT_TO_FLOAT(v[2]) );
  406.  
  407. }
  408.  
  409.  
  410. void APIENTRY glColor4bv( const GLbyte *v )
  411. {
  412.    GET_CONTEXT;
  413.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  414.                        BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
  415. }
  416.  
  417.  
  418. void APIENTRY glColor4dv( const GLdouble *v )
  419. {
  420.    GET_CONTEXT;
  421.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  422.                        (GLdouble) v[2], (GLdouble) v[3] );
  423. }
  424.  
  425.  
  426. void APIENTRY glColor4fv( const GLfloat *v )
  427. {
  428.    GET_CONTEXT;
  429.    (*CC->API.Color4f)( CC, v[0], v[1], v[2], v[3] );
  430. }
  431.  
  432.  
  433. void APIENTRY glColor4iv( const GLint *v )
  434. {
  435.    GET_CONTEXT;
  436.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  437.                        INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
  438. }
  439.  
  440.  
  441. void APIENTRY glColor4sv( const GLshort *v )
  442. {
  443.    GET_CONTEXT;
  444.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  445.                        SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
  446. }
  447.  
  448.  
  449. void APIENTRY glColor4ubv( const GLubyte *v )
  450. {
  451.    GET_CONTEXT;
  452.    (*CC->API.Color4ubv)( CC, v );
  453. }
  454.  
  455.  
  456. void APIENTRY glColor4uiv( const GLuint *v )
  457. {
  458.    GET_CONTEXT;
  459.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  460.                        UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
  461. }
  462.  
  463.  
  464. void APIENTRY glColor4usv( const GLushort *v )
  465. {
  466.    GET_CONTEXT;
  467.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  468.                        USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
  469. }
  470.  
  471.  
  472. void APIENTRY glColorMask( GLboolean red, GLboolean green,
  473.              GLboolean blue, GLboolean alpha )
  474. {
  475.    GET_CONTEXT;
  476.    CHECK_CONTEXT;
  477.    (*CC->API.ColorMask)(CC, red, green, blue, alpha);
  478. }
  479.  
  480.  
  481. void APIENTRY glColorMaterial( GLenum face, GLenum mode )
  482. {
  483.    GET_CONTEXT;
  484.    CHECK_CONTEXT;
  485.    (*CC->API.ColorMaterial)(CC, face, mode);
  486. }
  487.  
  488.  
  489. void APIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride,
  490.                      const GLvoid *ptr )
  491. {
  492.    GET_CONTEXT;
  493.    CHECK_CONTEXT;
  494.    (*CC->API.ColorPointer)(CC, size, type, stride, ptr);
  495. }
  496.  
  497.  
  498. void APIENTRY glColorTableEXT( GLenum target, GLenum internalFormat,
  499.                                GLsizei width, GLenum format, GLenum type,
  500.                                const GLvoid *table )
  501. {
  502.    struct gl_image *image;
  503.    GET_CONTEXT;
  504.    CHECK_CONTEXT;
  505.    image = gl_unpack_image( CC, width, 1, format, type, table );
  506.    (*CC->API.ColorTable)( CC, target, internalFormat, image );
  507.    if (image->RefCount == 0)
  508.       gl_free_image(image);
  509. }
  510.  
  511.  
  512. void APIENTRY glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, 
  513.                                   GLenum format, GLenum type,
  514.                                   const GLvoid *data )
  515. {
  516.    struct gl_image *image;
  517.    GET_CONTEXT;
  518.    CHECK_CONTEXT;
  519.    image = gl_unpack_image( CC, count, 1, format, type, data );
  520.    (*CC->API.ColorSubTable)( CC, target, start, image );
  521.    if (image->RefCount == 0)
  522.       gl_free_image(image);
  523. }
  524.  
  525.  
  526.  
  527. void APIENTRY glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  528.               GLenum type )
  529. {
  530.    GET_CONTEXT;
  531.    CHECK_CONTEXT;
  532.    (*CC->API.CopyPixels)(CC, x, y, width, height, type);
  533. }
  534.  
  535.  
  536. void APIENTRY glCopyTexImage1D( GLenum target, GLint level,
  537.                                 GLenum internalformat,
  538.                                 GLint x, GLint y,
  539.                                 GLsizei width, GLint border )
  540. {
  541.    GET_CONTEXT;
  542.    CHECK_CONTEXT;
  543.    (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
  544.                                  x, y, width, border );
  545. }
  546.  
  547.  
  548. void APIENTRY glCopyTexImage2D( GLenum target, GLint level,
  549.                                 GLenum internalformat,
  550.                                 GLint x, GLint y,
  551.                                 GLsizei width, GLsizei height, GLint border )
  552. {
  553.    GET_CONTEXT;
  554.    CHECK_CONTEXT;
  555.    (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
  556.                               x, y, width, height, border );
  557. }
  558.  
  559.  
  560. void APIENTRY glCopyTexSubImage1D( GLenum target, GLint level,
  561.                                    GLint xoffset, GLint x, GLint y,
  562.                                    GLsizei width )
  563. {
  564.    GET_CONTEXT;
  565.    CHECK_CONTEXT;
  566.    (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
  567. }
  568.  
  569.  
  570. void APIENTRY glCopyTexSubImage2D( GLenum target, GLint level,
  571.                                    GLint xoffset, GLint yoffset,
  572.                                    GLint x, GLint y,
  573.                                    GLsizei width, GLsizei height )
  574. {
  575.    GET_CONTEXT;
  576.    CHECK_CONTEXT;
  577.    (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
  578.                                  x, y, width, height );
  579. }
  580.  
  581.  
  582. /* 1.2 */
  583. void APIENTRY glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset,
  584.                                    GLint yoffset, GLint zoffset,
  585.                                    GLint x, GLint y, GLsizei width,
  586.                                    GLsizei height )
  587. {
  588.    GET_CONTEXT;
  589.    CHECK_CONTEXT;
  590.    (*CC->API.CopyTexSubImage3DEXT)( CC, target, level, xoffset, yoffset,
  591.                                     zoffset, x, y, width, height );
  592. }
  593.  
  594.  
  595.  
  596. void APIENTRY glCullFace( GLenum mode )
  597. {
  598.    GET_CONTEXT;
  599.    CHECK_CONTEXT;
  600.    (*CC->API.CullFace)(CC, mode);
  601. }
  602.  
  603.  
  604. void APIENTRY glDepthFunc( GLenum func )
  605. {
  606.    GET_CONTEXT;
  607.    CHECK_CONTEXT;
  608.    (*CC->API.DepthFunc)( CC, func );
  609. }
  610.  
  611.  
  612. void APIENTRY glDepthMask( GLboolean flag )
  613. {
  614.    GET_CONTEXT;
  615.    CHECK_CONTEXT;
  616.    (*CC->API.DepthMask)( CC, flag );
  617. }
  618.  
  619.  
  620. void APIENTRY glDepthRange( GLclampd near_val, GLclampd far_val )
  621. {
  622.    GET_CONTEXT;
  623.    CHECK_CONTEXT;
  624.    (*CC->API.DepthRange)( CC, near_val, far_val );
  625. }
  626.  
  627.  
  628. void APIENTRY glDeleteLists( GLuint list, GLsizei range )
  629. {
  630.    GET_CONTEXT;
  631.    CHECK_CONTEXT;
  632.    (*CC->API.DeleteLists)(CC, list, range);
  633. }
  634.  
  635.  
  636. void APIENTRY glDeleteTextures( GLsizei n, const GLuint *textures)
  637. {
  638.    GET_CONTEXT;
  639.    CHECK_CONTEXT;
  640.    (*CC->API.DeleteTextures)(CC, n, textures);
  641. }
  642.  
  643.  
  644. void APIENTRY glDisable( GLenum cap )
  645. {
  646.    GET_CONTEXT;
  647.    CHECK_CONTEXT;
  648.    (*CC->API.Disable)( CC, cap );
  649. }
  650.  
  651.  
  652. void APIENTRY glDisableClientState( GLenum cap )
  653. {
  654.    GET_CONTEXT;
  655.    CHECK_CONTEXT;
  656.    (*CC->API.DisableClientState)( CC, cap );
  657. }
  658.  
  659.  
  660. void APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count )
  661. {
  662.    GET_CONTEXT;
  663.    CHECK_CONTEXT;
  664.    (*CC->API.DrawArrays)(CC, mode, first, count);
  665. }
  666.  
  667.  
  668. void APIENTRY glDrawBuffer( GLenum mode )
  669. {
  670.    GET_CONTEXT;
  671.    CHECK_CONTEXT;
  672.    (*CC->API.DrawBuffer)(CC, mode);
  673. }
  674.  
  675.  
  676. void APIENTRY glDrawElements( GLenum mode, GLsizei count,
  677.                               GLenum type, const GLvoid *indices )
  678. {
  679.    GET_CONTEXT;
  680.    CHECK_CONTEXT;
  681.    (*CC->API.DrawElements)( CC, mode, count, type, indices );
  682. }
  683.  
  684.  
  685. void APIENTRY glDrawPixels( GLsizei width, GLsizei height,
  686.                             GLenum format, GLenum type, const GLvoid *pixels )
  687. {
  688.    GET_CONTEXT;
  689.    CHECK_CONTEXT;
  690.    if (!CC->DirectContext || CC->CompileFlag
  691.        || !gl_direct_DrawPixels(CC, &CC->Unpack, width, height,
  692.                                 format, type, pixels)) {
  693.       struct gl_image *image;
  694.       image = gl_unpack_image( CC, width, height, format, type, pixels );
  695.       (*CC->API.DrawPixels)( CC, image );
  696.       if (image->RefCount==0) {
  697.          /* image not in display list */
  698.          gl_free_image( image );
  699.       }
  700.    }
  701. }
  702.  
  703.  
  704. /* GL_VERSION_1_2 */
  705. void APIENTRY glDrawRangeElements( GLenum mode, GLuint start, GLuint end,
  706.                          GLsizei count, GLenum type, const GLvoid *indices )
  707. {
  708.    GET_CONTEXT;
  709.    CHECK_CONTEXT;
  710.    (*CC->API.DrawRangeElements)( CC, mode, start, end, count, type, indices );
  711. }
  712.  
  713.  
  714. void APIENTRY glEnable( GLenum cap )
  715. {
  716.    GET_CONTEXT;
  717.    CHECK_CONTEXT;
  718.    (*CC->API.Enable)( CC, cap );
  719. }
  720.  
  721.  
  722. void APIENTRY glEnableClientState( GLenum cap )
  723. {
  724.    GET_CONTEXT;
  725.    CHECK_CONTEXT;
  726.    (*CC->API.EnableClientState)( CC, cap );
  727. }
  728.  
  729.  
  730. void APIENTRY glEnd( void )
  731. {
  732.    GET_CONTEXT;
  733.    CHECK_CONTEXT;
  734.    (*CC->API.End)( CC );
  735. }
  736.  
  737.  
  738. void APIENTRY glEndList( void )
  739. {
  740.    GET_CONTEXT;
  741.    CHECK_CONTEXT;
  742.    (*CC->API.EndList)(CC);
  743. }
  744.  
  745.  
  746.  
  747.  
  748. void APIENTRY glEvalCoord1d( GLdouble u )
  749. {
  750.    GET_CONTEXT;
  751.    CHECK_CONTEXT;
  752.    (*CC->API.EvalCoord1f)( CC, (GLfloat) u );
  753. }
  754.  
  755.  
  756. void APIENTRY glEvalCoord1f( GLfloat u )
  757. {
  758.    GET_CONTEXT;
  759.    CHECK_CONTEXT;
  760.    (*CC->API.EvalCoord1f)( CC, u );
  761. }
  762.  
  763.  
  764. void APIENTRY glEvalCoord1dv( const GLdouble *u )
  765. {
  766.    GET_CONTEXT;
  767.    CHECK_CONTEXT;
  768.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  769. }
  770.  
  771.  
  772. void APIENTRY glEvalCoord1fv( const GLfloat *u )
  773. {
  774.    GET_CONTEXT;
  775.    CHECK_CONTEXT;
  776.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  777. }
  778.  
  779.  
  780. void APIENTRY glEvalCoord2d( GLdouble u, GLdouble v )
  781. {
  782.    GET_CONTEXT;
  783.    CHECK_CONTEXT;
  784.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u, (GLfloat) v );
  785. }
  786.  
  787.  
  788. void APIENTRY glEvalCoord2f( GLfloat u, GLfloat v )
  789. {
  790.    GET_CONTEXT;
  791.    CHECK_CONTEXT;
  792.    (*CC->API.EvalCoord2f)( CC, u, v );
  793. }
  794.  
  795.  
  796. void APIENTRY glEvalCoord2dv( const GLdouble *u )
  797. {
  798.    GET_CONTEXT;
  799.    CHECK_CONTEXT;
  800.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u[0], (GLfloat) u[1] );
  801. }
  802.  
  803.  
  804. void APIENTRY glEvalCoord2fv( const GLfloat *u )
  805. {
  806.    GET_CONTEXT;
  807.    CHECK_CONTEXT;
  808.    (*CC->API.EvalCoord2f)( CC, u[0], u[1] );
  809. }
  810.  
  811.  
  812. void APIENTRY glEvalPoint1( GLint i )
  813. {
  814.    GET_CONTEXT;
  815.    CHECK_CONTEXT;
  816.    (*CC->API.EvalPoint1)( CC, i );
  817. }
  818.  
  819.  
  820. void APIENTRY glEvalPoint2( GLint i, GLint j )
  821. {
  822.    GET_CONTEXT;
  823.    CHECK_CONTEXT;
  824.    (*CC->API.EvalPoint2)( CC, i, j );
  825. }
  826.  
  827.  
  828. void APIENTRY glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
  829. {
  830.    GET_CONTEXT;
  831.    CHECK_CONTEXT;
  832.    (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
  833. }
  834.  
  835.  
  836. void APIENTRY glEdgeFlag( GLboolean flag )
  837. {
  838.    GET_CONTEXT;
  839.    CHECK_CONTEXT;
  840.    (*CC->API.EdgeFlag)(CC, flag);
  841. }
  842.  
  843.  
  844. void APIENTRY glEdgeFlagv( const GLboolean *flag )
  845. {
  846.    GET_CONTEXT;
  847.    CHECK_CONTEXT;
  848.    (*CC->API.EdgeFlag)(CC, *flag);
  849. }
  850.  
  851.  
  852. void APIENTRY glEdgeFlagPointer( GLsizei stride, const GLboolean *ptr )
  853. {
  854.    GET_CONTEXT;
  855.    CHECK_CONTEXT;
  856.    (*CC->API.EdgeFlagPointer)(CC, stride, ptr);
  857. }
  858.  
  859.  
  860. void APIENTRY glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  861. {
  862.    GET_CONTEXT;
  863.    CHECK_CONTEXT;
  864.    (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
  865. }
  866.  
  867.  
  868. void APIENTRY glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
  869. {
  870.    GET_CONTEXT;
  871.    CHECK_CONTEXT;
  872.    (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
  873. }
  874.  
  875.  
  876. void APIENTRY glFinish( void )
  877. {
  878.    GET_CONTEXT;
  879.    CHECK_CONTEXT;
  880.    (*CC->API.Finish)(CC);
  881. }
  882.  
  883.  
  884. void APIENTRY glFlush( void )
  885. {
  886.    GET_CONTEXT;
  887.    CHECK_CONTEXT;
  888.    (*CC->API.Flush)(CC);
  889. }
  890.  
  891.  
  892. void APIENTRY glFogf( GLenum pname, GLfloat param )
  893. {
  894.    GET_CONTEXT;
  895.    CHECK_CONTEXT;
  896.    (*CC->API.Fogfv)(CC, pname, ¶m);
  897. }
  898.  
  899.  
  900. void APIENTRY glFogi( GLenum pname, GLint param )
  901. {
  902.    GLfloat fparam = (GLfloat) param;
  903.    GET_CONTEXT;
  904.    CHECK_CONTEXT;
  905.    (*CC->API.Fogfv)(CC, pname, &fparam);
  906. }
  907.  
  908.  
  909. void APIENTRY glFogfv( GLenum pname, const GLfloat *params )
  910. {
  911.    GET_CONTEXT;
  912.    CHECK_CONTEXT;
  913.    (*CC->API.Fogfv)(CC, pname, params);
  914. }
  915.  
  916.  
  917. void APIENTRY glFogiv( GLenum pname, const GLint *params )
  918. {
  919.    GLfloat p[4];
  920.    GET_CONTEXT;
  921.    CHECK_CONTEXT;
  922.  
  923.    switch (pname) {
  924.       case GL_FOG_MODE:
  925.       case GL_FOG_DENSITY:
  926.       case GL_FOG_START:
  927.       case GL_FOG_END:
  928.       case GL_FOG_INDEX:
  929.      p[0] = (GLfloat) *params;
  930.      break;
  931.       case GL_FOG_COLOR:
  932.      p[0] = INT_TO_FLOAT( params[0] );
  933.      p[1] = INT_TO_FLOAT( params[1] );
  934.      p[2] = INT_TO_FLOAT( params[2] );
  935.      p[3] = INT_TO_FLOAT( params[3] );
  936.      break;
  937.       default:
  938.          /* Error will be caught later in gl_Fogfv */
  939.          ;
  940.    }
  941.    (*CC->API.Fogfv)( CC, pname, p );
  942. }
  943.  
  944.  
  945.  
  946. void APIENTRY glFrontFace( GLenum mode )
  947. {
  948.    GET_CONTEXT;
  949.    CHECK_CONTEXT;
  950.    (*CC->API.FrontFace)(CC, mode);
  951. }
  952.  
  953.  
  954. void APIENTRY glFrustum( GLdouble left, GLdouble right,
  955.                          GLdouble bottom, GLdouble top,
  956.                          GLdouble nearval, GLdouble farval )
  957. {
  958.    GET_CONTEXT;
  959.    CHECK_CONTEXT;
  960.    (*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
  961. }
  962.  
  963.  
  964. GLuint APIENTRY glGenLists( GLsizei range )
  965. {
  966.    GET_CONTEXT;
  967.    CHECK_CONTEXT_RETURN(0);
  968.    return (*CC->API.GenLists)(CC, range);
  969. }
  970.  
  971.  
  972. void APIENTRY glGenTextures( GLsizei n, GLuint *textures )
  973. {
  974.    GET_CONTEXT;
  975.    CHECK_CONTEXT;
  976.    (*CC->API.GenTextures)(CC, n, textures);
  977. }
  978.  
  979.  
  980. void APIENTRY glGetBooleanv( GLenum pname, GLboolean *params )
  981. {
  982.    GET_CONTEXT;
  983.    CHECK_CONTEXT;
  984.    (*CC->API.GetBooleanv)(CC, pname, params);
  985. }
  986.  
  987.  
  988. void APIENTRY glGetClipPlane( GLenum plane, GLdouble *equation )
  989. {
  990.    GET_CONTEXT;
  991.    CHECK_CONTEXT;
  992.    (*CC->API.GetClipPlane)(CC, plane, equation);
  993. }
  994.  
  995.  
  996. void APIENTRY glGetColorTableEXT( GLenum target, GLenum format,
  997.                                   GLenum type, GLvoid *table )
  998. {
  999.    GET_CONTEXT;
  1000.    CHECK_CONTEXT;
  1001.    (*CC->API.GetColorTable)(CC, target, format, type, table);
  1002. }
  1003.  
  1004.  
  1005. void APIENTRY glGetColorTableParameterivEXT( GLenum target, GLenum pname,
  1006.                                              GLint *params )
  1007. {
  1008.    GET_CONTEXT;
  1009.    CHECK_CONTEXT;
  1010.    (*CC->API.GetColorTableParameteriv)(CC, target, pname, params);
  1011. }
  1012.  
  1013.  
  1014. void APIENTRY glGetColorTableParameterfvEXT( GLenum target, GLenum pname,
  1015.                                              GLfloat *params )
  1016. {
  1017.    GLint iparams;
  1018.    glGetColorTableParameterivEXT( target, pname, &iparams );
  1019.    *params = (GLfloat) iparams;
  1020. }
  1021.  
  1022.  
  1023. void APIENTRY glGetDoublev( GLenum pname, GLdouble *params )
  1024. {
  1025.    GET_CONTEXT;
  1026.    CHECK_CONTEXT;
  1027.    (*CC->API.GetDoublev)(CC, pname, params);
  1028. }
  1029.  
  1030.  
  1031. GLenum APIENTRY glGetError( void )
  1032. {
  1033.    GET_CONTEXT;
  1034.    if (!CC) {
  1035.       /* No current context */
  1036.       return (GLenum) GL_NO_ERROR;
  1037.    }
  1038.    return (*CC->API.GetError)(CC);
  1039. }
  1040.  
  1041.  
  1042. void APIENTRY glGetFloatv( GLenum pname, GLfloat *params )
  1043. {
  1044.    GET_CONTEXT;
  1045.    CHECK_CONTEXT;
  1046.    (*CC->API.GetFloatv)(CC, pname, params);
  1047. }
  1048.  
  1049.  
  1050. void APIENTRY glGetIntegerv( GLenum pname, GLint *params )
  1051. {
  1052.    GET_CONTEXT;
  1053.    CHECK_CONTEXT;
  1054.    (*CC->API.GetIntegerv)(CC, pname, params);
  1055. }
  1056.  
  1057.  
  1058. void APIENTRY glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
  1059. {
  1060.    GET_CONTEXT;
  1061.    CHECK_CONTEXT;
  1062.    (*CC->API.GetLightfv)(CC, light, pname, params);
  1063. }
  1064.  
  1065.  
  1066. void APIENTRY glGetLightiv( GLenum light, GLenum pname, GLint *params )
  1067. {
  1068.    GET_CONTEXT;
  1069.    CHECK_CONTEXT;
  1070.    (*CC->API.GetLightiv)(CC, light, pname, params);
  1071. }
  1072.  
  1073.  
  1074. void APIENTRY glGetMapdv( GLenum target, GLenum query, GLdouble *v )
  1075. {
  1076.    GET_CONTEXT;
  1077.    CHECK_CONTEXT;
  1078.    (*CC->API.GetMapdv)( CC, target, query, v );
  1079. }
  1080.  
  1081.  
  1082. void APIENTRY glGetMapfv( GLenum target, GLenum query, GLfloat *v )
  1083. {
  1084.    GET_CONTEXT;
  1085.    CHECK_CONTEXT;
  1086.    (*CC->API.GetMapfv)( CC, target, query, v );
  1087. }
  1088.  
  1089.  
  1090. void APIENTRY glGetMapiv( GLenum target, GLenum query, GLint *v )
  1091. {
  1092.    GET_CONTEXT;
  1093.    CHECK_CONTEXT;
  1094.    (*CC->API.GetMapiv)( CC, target, query, v );
  1095. }
  1096.  
  1097.  
  1098. void APIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
  1099. {
  1100.    GET_CONTEXT;
  1101.    CHECK_CONTEXT;
  1102.    (*CC->API.GetMaterialfv)(CC, face, pname, params);
  1103. }
  1104.  
  1105.  
  1106. void APIENTRY glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
  1107. {
  1108.    GET_CONTEXT;
  1109.    CHECK_CONTEXT;
  1110.    (*CC->API.GetMaterialiv)(CC, face, pname, params);
  1111. }
  1112.  
  1113.  
  1114. void APIENTRY glGetPixelMapfv( GLenum map, GLfloat *values )
  1115. {
  1116.    GET_CONTEXT;
  1117.    CHECK_CONTEXT;
  1118.    (*CC->API.GetPixelMapfv)(CC, map, values);
  1119. }
  1120.  
  1121.  
  1122. void APIENTRY glGetPixelMapuiv( GLenum map, GLuint *values )
  1123. {
  1124.    GET_CONTEXT;
  1125.    CHECK_CONTEXT;
  1126.    (*CC->API.GetPixelMapuiv)(CC, map, values);
  1127. }
  1128.  
  1129.  
  1130. void APIENTRY glGetPixelMapusv( GLenum map, GLushort *values )
  1131. {
  1132.    GET_CONTEXT;
  1133.    CHECK_CONTEXT;
  1134.    (*CC->API.GetPixelMapusv)(CC, map, values);
  1135. }
  1136.  
  1137.  
  1138. void APIENTRY glGetPointerv( GLenum pname, GLvoid **params )
  1139. {
  1140.    GET_CONTEXT;
  1141.    CHECK_CONTEXT;
  1142.    (*CC->API.GetPointerv)(CC, pname, params);
  1143. }
  1144.  
  1145.  
  1146. void APIENTRY glGetPolygonStipple( GLubyte *mask )
  1147. {
  1148.    GET_CONTEXT;
  1149.    CHECK_CONTEXT;
  1150.    (*CC->API.GetPolygonStipple)(CC, mask);
  1151. }
  1152.  
  1153.  
  1154. const GLubyte * APIENTRY glGetString( GLenum name )
  1155. {
  1156.    GET_CONTEXT;
  1157.    CHECK_CONTEXT_RETURN(NULL);
  1158.    return (*CC->API.GetString)(CC, name);
  1159. }
  1160.  
  1161.  
  1162.  
  1163. void APIENTRY glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
  1164. {
  1165.    GET_CONTEXT;
  1166.    CHECK_CONTEXT;
  1167.    (*CC->API.GetTexEnvfv)(CC, target, pname, params);
  1168. }
  1169.  
  1170.  
  1171. void APIENTRY glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
  1172. {
  1173.    GET_CONTEXT;
  1174.    CHECK_CONTEXT;
  1175.    (*CC->API.GetTexEnviv)(CC, target, pname, params);
  1176. }
  1177.  
  1178.  
  1179. void APIENTRY glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
  1180. {
  1181.    GET_CONTEXT;
  1182.    CHECK_CONTEXT;
  1183.    (*CC->API.GetTexGeniv)(CC, coord, pname, params);
  1184. }
  1185.  
  1186.  
  1187. void APIENTRY glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
  1188. {
  1189.    GET_CONTEXT;
  1190.    CHECK_CONTEXT;
  1191.    (*CC->API.GetTexGendv)(CC, coord, pname, params);
  1192. }
  1193.  
  1194.  
  1195. void APIENTRY glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
  1196. {
  1197.    GET_CONTEXT;
  1198.    CHECK_CONTEXT;
  1199.    (*CC->API.GetTexGenfv)(CC, coord, pname, params);
  1200. }
  1201.  
  1202.  
  1203.  
  1204. void APIENTRY glGetTexImage( GLenum target, GLint level, GLenum format,
  1205.                              GLenum type, GLvoid *pixels )
  1206. {
  1207.    GET_CONTEXT;
  1208.    CHECK_CONTEXT;
  1209.    (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
  1210. }
  1211.  
  1212.  
  1213. void APIENTRY glGetTexLevelParameterfv( GLenum target, GLint level,
  1214.                                         GLenum pname, GLfloat *params )
  1215. {
  1216.    GET_CONTEXT;
  1217.    CHECK_CONTEXT;
  1218.    (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
  1219. }
  1220.  
  1221.  
  1222. void APIENTRY glGetTexLevelParameteriv( GLenum target, GLint level,
  1223.                                         GLenum pname, GLint *params )
  1224. {
  1225.    GET_CONTEXT;
  1226.    CHECK_CONTEXT;
  1227.    (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
  1228. }
  1229.  
  1230.  
  1231.  
  1232.  
  1233. void APIENTRY glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params)
  1234. {
  1235.    GET_CONTEXT;
  1236.    CHECK_CONTEXT;
  1237.    (*CC->API.GetTexParameterfv)(CC, target, pname, params);
  1238. }
  1239.  
  1240.  
  1241. void APIENTRY glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
  1242. {
  1243.    GET_CONTEXT;
  1244.    CHECK_CONTEXT;
  1245.    (*CC->API.GetTexParameteriv)(CC, target, pname, params);
  1246. }
  1247.  
  1248.  
  1249. void APIENTRY glHint( GLenum target, GLenum mode )
  1250. {
  1251.    GET_CONTEXT;
  1252.    CHECK_CONTEXT;
  1253.    (*CC->API.Hint)(CC, target, mode);
  1254. }
  1255.  
  1256.  
  1257. void APIENTRY glIndexd( GLdouble c )
  1258. {
  1259.    GET_CONTEXT;
  1260.    (*CC->API.Indexf)( CC, (GLfloat) c );
  1261. }
  1262.  
  1263.  
  1264. void APIENTRY glIndexf( GLfloat c )
  1265. {
  1266.    GET_CONTEXT;
  1267.    (*CC->API.Indexf)( CC, c );
  1268. }
  1269.  
  1270.  
  1271. void APIENTRY glIndexi( GLint c )
  1272. {
  1273.    GET_CONTEXT;
  1274.    (*CC->API.Indexi)( CC, c );
  1275. }
  1276.  
  1277.  
  1278. void APIENTRY glIndexs( GLshort c )
  1279. {
  1280.    GET_CONTEXT;
  1281.    (*CC->API.Indexi)( CC, (GLint) c );
  1282. }
  1283.  
  1284.  
  1285. /* GL_VERSION_1_1 */
  1286. void APIENTRY glIndexub( GLubyte c )
  1287. {
  1288.    GET_CONTEXT;
  1289.    (*CC->API.Indexi)( CC, (GLint) c );
  1290. }
  1291.  
  1292.  
  1293. void APIENTRY glIndexdv( const GLdouble *c )
  1294. {
  1295.    GET_CONTEXT;
  1296.    (*CC->API.Indexf)( CC, (GLfloat) *c );
  1297. }
  1298.  
  1299.  
  1300. void APIENTRY glIndexfv( const GLfloat *c )
  1301. {
  1302.    GET_CONTEXT;
  1303.    (*CC->API.Indexf)( CC, *c );
  1304. }
  1305.  
  1306.  
  1307. void APIENTRY glIndexiv( const GLint *c )
  1308. {
  1309.    GET_CONTEXT;
  1310.    (*CC->API.Indexi)( CC, *c );
  1311. }
  1312.  
  1313.  
  1314. void APIENTRY glIndexsv( const GLshort *c )
  1315. {
  1316.    GET_CONTEXT;
  1317.    (*CC->API.Indexi)( CC, (GLint) *c );
  1318. }
  1319.  
  1320.  
  1321. /* GL_VERSION_1_1 */
  1322. void APIENTRY glIndexubv( const GLubyte *c )
  1323. {
  1324.    GET_CONTEXT;
  1325.    (*CC->API.Indexi)( CC, (GLint) *c );
  1326. }
  1327.  
  1328.  
  1329. void APIENTRY glIndexMask( GLuint mask )
  1330. {
  1331.    GET_CONTEXT;
  1332.    (*CC->API.IndexMask)(CC, mask);
  1333. }
  1334.  
  1335.  
  1336. void APIENTRY glIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1337. {
  1338.    GET_CONTEXT;
  1339.    CHECK_CONTEXT;
  1340.    (*CC->API.IndexPointer)(CC, type, stride, ptr);
  1341. }
  1342.  
  1343.  
  1344. void APIENTRY glInterleavedArrays( GLenum format, GLsizei stride,
  1345.                                    const GLvoid *pointer )
  1346. {
  1347.    GET_CONTEXT;
  1348.    CHECK_CONTEXT;
  1349.    (*CC->API.InterleavedArrays)( CC, format, stride, pointer );
  1350. }
  1351.  
  1352.  
  1353. void APIENTRY glInitNames( void )
  1354. {
  1355.    GET_CONTEXT;
  1356.    CHECK_CONTEXT;
  1357.    (*CC->API.InitNames)(CC);
  1358. }
  1359.  
  1360.  
  1361. GLboolean APIENTRY glIsList( GLuint list )
  1362. {
  1363.    GET_CONTEXT;
  1364.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1365.    return (*CC->API.IsList)(CC, list);
  1366. }
  1367.  
  1368.  
  1369. GLboolean APIENTRY glIsTexture( GLuint texture )
  1370. {
  1371.    GET_CONTEXT;
  1372.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1373.    return (*CC->API.IsTexture)(CC, texture);
  1374. }
  1375.  
  1376.  
  1377. void APIENTRY glLightf( GLenum light, GLenum pname, GLfloat param )
  1378. {
  1379.    GET_CONTEXT;
  1380.    CHECK_CONTEXT;
  1381.    (*CC->API.Lightfv)( CC, light, pname, ¶m, 1 );
  1382. }
  1383.  
  1384.  
  1385.  
  1386. void APIENTRY glLighti( GLenum light, GLenum pname, GLint param )
  1387. {
  1388.    GLfloat fparam = (GLfloat) param;
  1389.    GET_CONTEXT;
  1390.    CHECK_CONTEXT;
  1391.    (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
  1392. }
  1393.  
  1394.  
  1395.  
  1396. void APIENTRY glLightfv( GLenum light, GLenum pname, const GLfloat *params )
  1397. {
  1398.    GET_CONTEXT;
  1399.    CHECK_CONTEXT;
  1400.    (*CC->API.Lightfv)( CC, light, pname, params, 4 );
  1401. }
  1402.  
  1403.  
  1404.  
  1405. void APIENTRY glLightiv( GLenum light, GLenum pname, const GLint *params )
  1406. {
  1407.    GLfloat fparam[4];
  1408.    GET_CONTEXT;
  1409.    CHECK_CONTEXT;
  1410.  
  1411.    switch (pname) {
  1412.       case GL_AMBIENT:
  1413.       case GL_DIFFUSE:
  1414.       case GL_SPECULAR:
  1415.          fparam[0] = INT_TO_FLOAT( params[0] );
  1416.          fparam[1] = INT_TO_FLOAT( params[1] );
  1417.          fparam[2] = INT_TO_FLOAT( params[2] );
  1418.          fparam[3] = INT_TO_FLOAT( params[3] );
  1419.          break;
  1420.       case GL_POSITION:
  1421.          fparam[0] = (GLfloat) params[0];
  1422.          fparam[1] = (GLfloat) params[1];
  1423.          fparam[2] = (GLfloat) params[2];
  1424.          fparam[3] = (GLfloat) params[3];
  1425.          break;
  1426.       case GL_SPOT_DIRECTION:
  1427.          fparam[0] = (GLfloat) params[0];
  1428.          fparam[1] = (GLfloat) params[1];
  1429.          fparam[2] = (GLfloat) params[2];
  1430.          break;
  1431.       case GL_SPOT_EXPONENT:
  1432.       case GL_SPOT_CUTOFF:
  1433.       case GL_CONSTANT_ATTENUATION:
  1434.       case GL_LINEAR_ATTENUATION:
  1435.       case GL_QUADRATIC_ATTENUATION:
  1436.          fparam[0] = (GLfloat) params[0];
  1437.          break;
  1438.       default:
  1439.          /* error will be caught later in gl_Lightfv */
  1440.          ;
  1441.    }
  1442.    (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
  1443. }
  1444.  
  1445.  
  1446.  
  1447. void APIENTRY glLightModelf( GLenum pname, GLfloat param )
  1448. {
  1449.    GET_CONTEXT;
  1450.    CHECK_CONTEXT;
  1451.    (*CC->API.LightModelfv)( CC, pname, ¶m );
  1452. }
  1453.  
  1454.  
  1455. void APIENTRY glLightModeli( GLenum pname, GLint param )
  1456. {
  1457.    GLfloat fparam[4];
  1458.    GET_CONTEXT;
  1459.    CHECK_CONTEXT;
  1460.    fparam[0] = (GLfloat) param;
  1461.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1462. }
  1463.  
  1464.  
  1465. void APIENTRY glLightModelfv( GLenum pname, const GLfloat *params )
  1466. {
  1467.    GET_CONTEXT;
  1468.    CHECK_CONTEXT;
  1469.    (*CC->API.LightModelfv)( CC, pname, params );
  1470. }
  1471.  
  1472.  
  1473. void APIENTRY glLightModeliv( GLenum pname, const GLint *params )
  1474. {
  1475.    GLfloat fparam[4];
  1476.    GET_CONTEXT;
  1477.    CHECK_CONTEXT;
  1478.  
  1479.    switch (pname) {
  1480.       case GL_LIGHT_MODEL_AMBIENT:
  1481.          fparam[0] = INT_TO_FLOAT( params[0] );
  1482.          fparam[1] = INT_TO_FLOAT( params[1] );
  1483.          fparam[2] = INT_TO_FLOAT( params[2] );
  1484.          fparam[3] = INT_TO_FLOAT( params[3] );
  1485.          break;
  1486.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1487.       case GL_LIGHT_MODEL_TWO_SIDE:
  1488.          fparam[0] = (GLfloat) params[0];
  1489.          break;
  1490.       default:
  1491.          /* Error will be caught later in gl_LightModelfv */
  1492.          ;
  1493.    }
  1494.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1495. }
  1496.  
  1497.  
  1498. void APIENTRY glLineWidth( GLfloat width )
  1499. {
  1500.    GET_CONTEXT;
  1501.    CHECK_CONTEXT;
  1502.    (*CC->API.LineWidth)(CC, width);
  1503. }
  1504.  
  1505.  
  1506. void APIENTRY glLineStipple( GLint factor, GLushort pattern )
  1507. {
  1508.    GET_CONTEXT;
  1509.    CHECK_CONTEXT;
  1510.    (*CC->API.LineStipple)(CC, factor, pattern);
  1511. }
  1512.  
  1513.  
  1514. void APIENTRY glListBase( GLuint base )
  1515. {
  1516.    GET_CONTEXT;
  1517.    CHECK_CONTEXT;
  1518.    (*CC->API.ListBase)(CC, base);
  1519. }
  1520.  
  1521.  
  1522. void APIENTRY glLoadIdentity( void )
  1523. {
  1524.    GET_CONTEXT;
  1525.    CHECK_CONTEXT;
  1526.    (*CC->API.LoadIdentity)( CC );
  1527. }
  1528.  
  1529.  
  1530. void APIENTRY glLoadMatrixd( const GLdouble *m )
  1531. {
  1532.    GLfloat fm[16];
  1533.    GLuint i;
  1534.    GET_CONTEXT;
  1535.    CHECK_CONTEXT;
  1536.  
  1537.    for (i=0;i<16;i++) {
  1538.       fm[i] = (GLfloat) m[i];
  1539.    }
  1540.  
  1541.    (*CC->API.LoadMatrixf)( CC, fm );
  1542. }
  1543.  
  1544.  
  1545. void APIENTRY glLoadMatrixf( const GLfloat *m )
  1546. {
  1547.    GET_CONTEXT;
  1548.    CHECK_CONTEXT;
  1549.    (*CC->API.LoadMatrixf)( CC, m );
  1550. }
  1551.  
  1552.  
  1553. void APIENTRY glLoadName( GLuint name )
  1554. {
  1555.    GET_CONTEXT;
  1556.    CHECK_CONTEXT;
  1557.    (*CC->API.LoadName)(CC, name);
  1558. }
  1559.  
  1560.  
  1561. void APIENTRY glLogicOp( GLenum opcode )
  1562. {
  1563.    GET_CONTEXT;
  1564.    CHECK_CONTEXT;
  1565.    (*CC->API.LogicOp)(CC, opcode);
  1566. }
  1567.  
  1568.  
  1569.  
  1570. void APIENTRY glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  1571.                        GLint order, const GLdouble *points )
  1572. {
  1573.    GLfloat *pnts;
  1574.    GLboolean retain;
  1575.    GET_CONTEXT;
  1576.    CHECK_CONTEXT;
  1577.  
  1578.    pnts = gl_copy_map_points1d( target, stride, order, points );
  1579.    retain = CC->CompileFlag;
  1580.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1581. }
  1582.  
  1583.  
  1584. void APIENTRY glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1585.                        GLint order, const GLfloat *points )
  1586. {
  1587.    GLfloat *pnts;
  1588.    GLboolean retain;
  1589.    GET_CONTEXT;
  1590.    CHECK_CONTEXT;
  1591.  
  1592.    pnts = gl_copy_map_points1f( target, stride, order, points );
  1593.    retain = CC->CompileFlag;
  1594.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1595. }
  1596.  
  1597.  
  1598. void APIENTRY glMap2d( GLenum target,
  1599.                        GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
  1600.                        GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
  1601.                        const GLdouble *points )
  1602. {
  1603.    GLfloat *pnts;
  1604.    GLboolean retain;
  1605.    GET_CONTEXT;
  1606.    CHECK_CONTEXT;
  1607.  
  1608.    pnts = gl_copy_map_points2d( target, ustride, uorder,
  1609.                                 vstride, vorder, points );
  1610.    retain = CC->CompileFlag;
  1611.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1612.                      v1, v2, vstride, vorder, pnts, retain );
  1613. }
  1614.  
  1615.  
  1616. void APIENTRY glMap2f( GLenum target,
  1617.                        GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1618.                        GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1619.                        const GLfloat *points )
  1620. {
  1621.    GLfloat *pnts;
  1622.    GLboolean retain;
  1623.    GET_CONTEXT;
  1624.    CHECK_CONTEXT;
  1625.  
  1626.    pnts = gl_copy_map_points2f( target, ustride, uorder,
  1627.                                 vstride, vorder, points );
  1628.    retain = CC->CompileFlag;
  1629.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1630.                      v1, v2, vstride, vorder, pnts, retain );
  1631. }
  1632.  
  1633.  
  1634. void APIENTRY glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
  1635. {
  1636.    GET_CONTEXT;
  1637.    CHECK_CONTEXT;
  1638.    (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
  1639. }
  1640.  
  1641.  
  1642. void APIENTRY glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
  1643. {
  1644.    GET_CONTEXT;
  1645.    CHECK_CONTEXT;
  1646.    (*CC->API.MapGrid1f)( CC, un, u1, u2 );
  1647. }
  1648.  
  1649.  
  1650. void APIENTRY glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
  1651.                            GLint vn, GLdouble v1, GLdouble v2 )
  1652. {
  1653.    GET_CONTEXT;
  1654.    CHECK_CONTEXT;
  1655.    (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
  1656.                          vn, (GLfloat) v1, (GLfloat) v2 );
  1657. }
  1658.  
  1659.  
  1660. void APIENTRY glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
  1661.                            GLint vn, GLfloat v1, GLfloat v2 )
  1662. {
  1663.    GET_CONTEXT;
  1664.    CHECK_CONTEXT;
  1665.    (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
  1666. }
  1667.  
  1668.  
  1669. void APIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param )
  1670. {
  1671.    GET_CONTEXT;
  1672.    CHECK_CONTEXT;
  1673.    (*CC->API.Materialfv)( CC, face, pname, ¶m );
  1674. }
  1675.  
  1676.  
  1677.  
  1678. void APIENTRY glMateriali( GLenum face, GLenum pname, GLint param )
  1679. {
  1680.    GLfloat fparam[4];
  1681.    GET_CONTEXT;
  1682.    CHECK_CONTEXT;
  1683.    fparam[0] = (GLfloat) param;
  1684.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1685. }
  1686.  
  1687.  
  1688. void APIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
  1689. {
  1690.    GET_CONTEXT;
  1691.    CHECK_CONTEXT;
  1692.    (*CC->API.Materialfv)( CC, face, pname, params );
  1693. }
  1694.  
  1695.  
  1696. void APIENTRY glMaterialiv( GLenum face, GLenum pname, const GLint *params )
  1697. {
  1698.    GLfloat fparam[4];
  1699.    GET_CONTEXT;
  1700.    CHECK_CONTEXT;
  1701.    switch (pname) {
  1702.       case GL_AMBIENT:
  1703.       case GL_DIFFUSE:
  1704.       case GL_SPECULAR:
  1705.       case GL_EMISSION:
  1706.       case GL_AMBIENT_AND_DIFFUSE:
  1707.          fparam[0] = INT_TO_FLOAT( params[0] );
  1708.          fparam[1] = INT_TO_FLOAT( params[1] );
  1709.          fparam[2] = INT_TO_FLOAT( params[2] );
  1710.          fparam[3] = INT_TO_FLOAT( params[3] );
  1711.          break;
  1712.       case GL_SHININESS:
  1713.          fparam[0] = (GLfloat) params[0];
  1714.          break;
  1715.       case GL_COLOR_INDEXES:
  1716.          fparam[0] = (GLfloat) params[0];
  1717.          fparam[1] = (GLfloat) params[1];
  1718.          fparam[2] = (GLfloat) params[2];
  1719.          break;
  1720.       default:
  1721.          /* Error will be caught later in gl_Materialfv */
  1722.          ;
  1723.    }
  1724.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1725. }
  1726.  
  1727.  
  1728. void APIENTRY glMatrixMode( GLenum mode )
  1729. {
  1730.    GET_CONTEXT;
  1731.    CHECK_CONTEXT;
  1732.    (*CC->API.MatrixMode)( CC, mode );
  1733. }
  1734.  
  1735.  
  1736. void APIENTRY glMultMatrixd( const GLdouble *m )
  1737. {
  1738.    GLfloat fm[16];
  1739.    GLuint i;
  1740.    GET_CONTEXT;
  1741.    CHECK_CONTEXT;
  1742.  
  1743.    for (i=0;i<16;i++) {
  1744.       fm[i] = (GLfloat) m[i];
  1745.    }
  1746.  
  1747.    (*CC->API.MultMatrixf)( CC, fm );
  1748. }
  1749.  
  1750.  
  1751. void APIENTRY glMultMatrixf( const GLfloat *m )
  1752. {
  1753.    GET_CONTEXT;
  1754.    CHECK_CONTEXT;
  1755.    (*CC->API.MultMatrixf)( CC, m );
  1756. }
  1757.  
  1758.  
  1759. void APIENTRY glNewList( GLuint list, GLenum mode )
  1760. {
  1761.    GET_CONTEXT;
  1762.    CHECK_CONTEXT;
  1763.    (*CC->API.NewList)(CC, list, mode);
  1764. }
  1765.  
  1766. void APIENTRY glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
  1767. {
  1768.    GET_CONTEXT;
  1769.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(nx),
  1770.                         BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
  1771. }
  1772.  
  1773.  
  1774. void APIENTRY glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
  1775. {
  1776.    GLfloat fx, fy, fz;
  1777.    GET_CONTEXT;
  1778.    if (ABSD(nx)<0.00001)   fx = 0.0F;   else  fx = nx;
  1779.    if (ABSD(ny)<0.00001)   fy = 0.0F;   else  fy = ny;
  1780.    if (ABSD(nz)<0.00001)   fz = 0.0F;   else  fz = nz;
  1781.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1782. }
  1783.  
  1784.  
  1785. void APIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
  1786. {
  1787.    GET_CONTEXT;
  1788. #ifdef SHORTCUT
  1789.    if (CC->CompileFlag) {
  1790.       (*CC->Save.Normal3f)( CC, nx, ny, nz );
  1791.    }
  1792.    else {
  1793.       /* Execute */
  1794.       CC->Current.Normal[0] = nx;
  1795.       CC->Current.Normal[1] = ny;
  1796.       CC->Current.Normal[2] = nz;
  1797.       CC->VB->MonoNormal = GL_FALSE;
  1798.    }
  1799. #else
  1800.    (*CC->API.Normal3f)( CC, nx, ny, nz );
  1801. #endif
  1802. }
  1803.  
  1804.  
  1805. void APIENTRY glNormal3i( GLint nx, GLint ny, GLint nz )
  1806. {
  1807.    GET_CONTEXT;
  1808.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(nx),
  1809.                         INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
  1810. }
  1811.  
  1812.  
  1813. void APIENTRY glNormal3s( GLshort nx, GLshort ny, GLshort nz )
  1814. {
  1815.    GET_CONTEXT;
  1816.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(nx),
  1817.                         SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
  1818. }
  1819.  
  1820.  
  1821. void APIENTRY glNormal3bv( const GLbyte *v )
  1822. {
  1823.    GET_CONTEXT;
  1824.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(v[0]),
  1825.                         BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
  1826. }
  1827.  
  1828.  
  1829. void APIENTRY glNormal3dv( const GLdouble *v )
  1830. {
  1831.    GLfloat fx, fy, fz;
  1832.    GET_CONTEXT;
  1833.    if (ABSD(v[0])<0.00001)   fx = 0.0F;   else  fx = v[0];
  1834.    if (ABSD(v[1])<0.00001)   fy = 0.0F;   else  fy = v[1];
  1835.    if (ABSD(v[2])<0.00001)   fz = 0.0F;   else  fz = v[2];
  1836.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1837. }
  1838.  
  1839.  
  1840. void APIENTRY glNormal3fv( const GLfloat *v )
  1841. {
  1842.    GET_CONTEXT;
  1843. #ifdef SHORTCUT
  1844.    if (CC->CompileFlag) {
  1845.       (*CC->Save.Normal3fv)( CC, v );
  1846.    }
  1847.    else {
  1848.       /* Execute */
  1849.       GLfloat *n = CC->Current.Normal;
  1850.       n[0] = v[0];
  1851.       n[1] = v[1];
  1852.       n[2] = v[2];
  1853.       CC->VB->MonoNormal = GL_FALSE;
  1854.    }
  1855. #else
  1856.    (*CC->API.Normal3fv)( CC, v );
  1857. #endif
  1858. }
  1859.  
  1860.  
  1861. void APIENTRY glNormal3iv( const GLint *v )
  1862. {
  1863.    GET_CONTEXT;
  1864.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(v[0]),
  1865.                         INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
  1866. }
  1867.  
  1868.  
  1869. void APIENTRY glNormal3sv( const GLshort *v )
  1870. {
  1871.    GET_CONTEXT;
  1872.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(v[0]),
  1873.                         SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
  1874. }
  1875.  
  1876.  
  1877. void APIENTRY glNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1878. {
  1879.    GET_CONTEXT;
  1880.    CHECK_CONTEXT;
  1881.    (*CC->API.NormalPointer)(CC, type, stride, ptr);
  1882. }
  1883.  
  1884.